#include <vcl.h>
#pragma hdrstop

#include <Eic.h>
#include "MTAG_Outils.h"
#include "uParamCourrierEtCarnAdr.h" //Pour GetRepsCourrier

#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck est utilisé pour être sûr que les composants créés n'ont
// aucune fonction virtuelle pure.
//
#define MODULE_TAG MTAG_CCOURRIER

#include "CCourrier.h"

static inline void ValidCtrCheck(CCourrier *)
{
   new CCourrier(NULL);
}
/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
__fastcall TContrainteTailleRichEdit::TContrainteTailleRichEdit(TNotifyEvent OnHauteurChange,
                                                                TNotifyEvent OnMargeChange)
{
try
   {
   m_iHEnTeteMax     = SANS_CONTRAINTE;
   m_iHCorpsMax      = SANS_CONTRAINTE;
   m_iHPiedMax       = SANS_CONTRAINTE;
   m_iMargeG         = SANS_CONTRAINTE;
   m_iMargeD         = SANS_CONTRAINTE;
   m_iMargeH         = SANS_CONTRAINTE;
   m_iMargeB         = SANS_CONTRAINTE;
   m_OnHauteurChange = OnHauteurChange;
   m_OnMargeChange   = OnMargeChange;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(1), e);
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetHEnTeteMax (int iHEnTeteMax)
{
if (m_iHEnTeteMax == iHEnTeteMax)
   return;

m_iHEnTeteMax = iHEnTeteMax;
if (m_OnHauteurChange)
   m_OnHauteurChange(this);
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetHCorpsMax (int iHCorpsMax)
{
if (m_iHCorpsMax == iHCorpsMax)
   return;

m_iHCorpsMax = iHCorpsMax;
if (m_OnHauteurChange)
   m_OnHauteurChange(this);
}
/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetHPiedMax (int iHPiedMax)
{
if (m_iHPiedMax == iHPiedMax)
   return;

m_iHPiedMax = iHPiedMax;
if (m_OnHauteurChange)
   m_OnHauteurChange(this);
} 

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetMargeG(int iMargeG)
{
if (m_iMargeG == iMargeG)
   return;

m_iMargeG = iMargeG;
if (m_OnMargeChange)
   m_OnMargeChange(this);
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetMargeD (int iMargeD)
{
if (m_iMargeD == iMargeD)
   return;

m_iMargeD = iMargeD;
if (m_OnMargeChange)
   m_OnMargeChange(this);
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetMargeH (int iMargeH)
{
if (m_iMargeH == iMargeH)
   return;

m_iMargeH = iMargeH;
if (m_OnMargeChange)
   m_OnMargeChange(this);
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall TContrainteTailleRichEdit::SetMargeB (int iMargeB)
{
if (m_iMargeB == iMargeB)
   return;

m_iMargeB = iMargeB;
if (m_OnMargeChange)
   m_OnMargeChange(this);
}


/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
__fastcall tsConfigBPL::tsConfigBPL()
   {
   FctGetValueOfVar = NULL;
   FctGetDescriptionModele = NULL;
   FctActionModele = NULL;
   FctModeleIsVisible = NULL;
   bGererEnTeteEtPiedDePage = true;
   lstColonnes = new TList;

   sContrainteTaille.iHEnTeteMax = SANS_CONTRAINTE;
   sContrainteTaille.iHCorpsMax  = SANS_CONTRAINTE;
   sContrainteTaille.iHPiedMax   = SANS_CONTRAINTE;
   }

__fastcall tsConfigBPL::~tsConfigBPL()
   {
   ASSERT(!lstColonnes->Count);
   delete lstColonnes;          lstColonnes = NULL;
   FctGetValueOfVar = NULL;
   FctGetDescriptionModele = NULL;
   FctActionModele = NULL;
   FctModeleIsVisible = NULL;
   }


__fastcall TColParametrable::TColParametrable(Classes::TCollection* Collection)
                             :TCollectionItem(Collection)
{
   m_bVisible = true;
   m_TypeColonne = colNonDefinie;
   m_shWidth = 50;
   m_bAjusterLargeur = false;
   m_slListe = new TStringList;
   m_iOrdre = 0;
}

void __fastcall TColParametrable::SetListeParametrable(TStringList *slListeParametrable)
{
m_slListe->Assign(slListeParametrable);
}


void __fastcall TColParametrable::SetLibelleCol (const AnsiString aLibelle)
{
m_aLibelleCol = aLibelle;
if (m_aLibelleCol == "Logiciel")
   m_TypeColonne = colLogiciel;
else if (m_aLibelleCol == "Catégorie")
   m_TypeColonne = colCateg;
else if (m_aLibelleCol == "Courriers")
   m_TypeColonne = colNom;
else if (m_aLibelleCol == "Papier en-tête")
   m_TypeColonne = colPapierEnTete;
else if (m_aLibelleCol == "Origine")
   m_TypeColonne = colOrigine;
else if (m_aLibelleCol == "Paramétrable 1")
   m_TypeColonne = colParam1;
else if (m_aLibelleCol == "Paramétrable 2")
   m_TypeColonne = colParam2;
}

void __fastcall TColParametrable::SetTypeColonne (TCol TypeColonne)
{
if (TypeColonne != colNonDefinie)
   for (int i=0 ; i < Collection->Count ; i++)
      if (Collection->Items[i] != this && ((TColParametrable*)Collection->Items[i])->TypeColonne == TypeColonne)
         {
         ShowMessage("Impossible : Une colonne de ce type existe déjà");
         return;
         }
m_TypeColonne = TypeColonne;
}

void __fastcall TColParametrable::SetAjusterLargeur (bool bAjusterLargeur)
{
if (bAjusterLargeur)
   for (int i=0 ; i < Collection->Count ; i++)
      if (Collection->Items[i] != this && ((TColParametrable*)Collection->Items[i])->AjusterLargeur == true)
         {
         ShowMessage("Impossible : Une colonne est déjà réglé sur \"Ajuster largeur\".");
         return;
         }
m_bAjusterLargeur = bAjusterLargeur;
}

AnsiString __fastcall TColParametrable::GetDisplayName()
{
return m_aLibelleCol;
}

__fastcall TColParametrable::~TColParametrable(void)
{
delete m_slListe;       m_slListe = NULL;
}

void __fastcall TColParametrable::Assign(Classes::TPersistent* Source)
{
ASSERT(false); //Code non écrit
}


/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
__fastcall TListColParametrables::TListColParametrables(CCourrier* AOwner)
    : TCollection(__classid(TColParametrable))
{
TColParametrable *NouvelleCol = NULL;
try
   {
   m_Owner = AOwner;

   /// Initialisation des colonnes
   /////////////////////////////////////////////////////////////////////////////
   NouvelleCol = (TColParametrable*) Add();
   NouvelleCol->Libelle = "Logiciel";
   NouvelleCol->Width   = 100;
   NouvelleCol->Ordre = 0;
   NouvelleCol = (TColParametrable*) Add();
   NouvelleCol->Libelle = "Catégorie";
   NouvelleCol->Width   = 85;
   NouvelleCol->Ordre = 1;
   NouvelleCol = (TColParametrable*) Add();
   NouvelleCol->Libelle = "Courriers";
   NouvelleCol->Width   = 150;
   NouvelleCol->AjusterLargeur = true;
   NouvelleCol->Ordre = 2;
   NouvelleCol = (TColParametrable*) Add();
   NouvelleCol->Libelle = "Papier en-tête";
   NouvelleCol->Width   = 55;
   NouvelleCol->Ordre = 3;
   NouvelleCol = (TColParametrable*) Add();
   NouvelleCol->Libelle = "Origine";
   NouvelleCol->Width   = 65;
   NouvelleCol->Ordre = 4;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(400), e);
   }
}

Classes::TPersistent* __fastcall TListColParametrables::GetOwner(void)
   {
   return (TPersistent*)m_Owner;
   }

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
__fastcall CCourrier::CCourrier(TComponent* Owner)
   : TCustomPanel(Owner)
{
try
   {
   hEditeur = NULL;
   HandleForm = NULL;
   FctGetValueOfVar = NULL;
   FctGetDescriptionModele = NULL;
   m_FctQueryActionModele  = NULL;
   m_FctActionModele       = NULL;
   m_FctModeleIsVisible    = NULL;
   m_bAffichageDemande = false;
   m_aLogiciel = EmptyStr;
   m_aCategorie = EmptyStr;
   m_aCategorieVariables = EmptyStr;
   m_eLangue      = lngFRANCAIS;
   m_eOrientation = eOrLibre;
   m_bUtiliseCarnAdr = false;
   m_bProtegerModelesFournis = false;
   m_bMultiLangue = false;
   m_bGererEnTeteEtPiedDePage = true;
   m_ContrainteTaille = new TContrainteTailleRichEdit((TNotifyEvent)NULL, (TNotifyEvent)NULL);
   m_ListCol = new TListColParametrables(this);
   aFileNameEicEdito = EmptyStr;
   _GererCourriers = NULL;
   _GetCoordDossier    = NULL;
   _ChangerCoorDoss    = NULL;
   _DesallouerEcran    = NULL;
   _ChangerLangue      = NULL;
   _ChangerOrientation = NULL;
   ModeParametrage = false;

   OnResize = MyOnResize;
   if (!ComponentState.Contains(csDesigning))
      {
      GetRepsCourrier(&aFileNameEicEdito);
      aFileNameEicEdito += NOM_DLL_EDITEUR;
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(500), e);
   }
}

/*******************************************************************************
unsigned long __fastcall CCourrier::GetNoCoord()

P.S : Retourne le Numéro de coordonné du dossier.
*******************************************************************************/
unsigned long __fastcall CCourrier::GetNoCoord()
{

try
   {
   if (!hEditeur)
      throw EAbort("La fonction \"Afficher\" doit d'abord être lancée");

   if (!_GetCoordDossier)
      {
      _GetCoordDossier = (FctGetCoordDossier)GetProcAddress(hEditeur, "_GetCoordDossier" );
      if( !_GetCoordDossier )
        throw EAbort( "Impossible de charger la fonction _GetCoordDossier.");
      }
   nNoCoord = _GetCoordDossier();
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(530), e);
   }
return nNoCoord;
}

/*******************************************************************************
bool __fastcall CCourrier::Afficher(unsigned long NoCoord,
                                    const AnsiString &aLogicielDefaut = EmptyStr,
                                    const AnsiString &aCategorieDefaut = EmptyStr,
                                    const AnsiString &aLibelleDefaut = EmptyStr,
                                    )

Fonction : Affiche l'écran.

Paramètres d'entrée : aLogicielDefaut  :   Indique quel
                      aCategorieDefaut :      est le modèle qui sera sélectionné
                      aLibelleDefaut   :         par défaut
P.S : return false si NoCoord, ne correspond à rien ou s'il est à 0.
      L'éditeur se lance quand même, mais il faudra récupérer le nouveau numéro
      généré à l'aide de GetCoordDoss().
      Ce numéro permet de mémoriser les émetteurs et destinataires associés à
      chaques courriers.
*******************************************************************************/
bool __fastcall CCourrier::Afficher(unsigned long NoCoord,
                                    const AnsiString &aLogicielDefaut /*= EmptyStr*/,
                                    const AnsiString &aCategorieDefaut /*= EmptyStr*/,
                                    const AnsiString &aLibelleDefaut /*= EmptyStr*/
                                    )
{
tsConfigBPL sConfig;
eErrCourriers NumErreur;
bool bRetour = true;
static bool bIsOnAffiche;
TParamColCourrier *sParamColCourrier = NULL;
TColParametrable *sColParametrable = NULL;

try {
    if (bIsOnAffiche)
       return true;

    bIsOnAffiche = true;
    nNoCoord = NoCoord;

   if (!hEditeur)
      {
      if((hEditeur = LoadLibrary(aFileNameEicEdito.c_str())) == NULL)
         throw EAbort("Librairie "+ aFileNameEicEdito + " absente.");
      }
    if (!_GererCourriers)
       {
       _GererCourriers = (FctGererCourriers)GetProcAddress( hEditeur, "_GererCourriers" );
       if( !_GererCourriers )
         throw EAbort( "Impossible de charger la fonction _GererCourriers.");
       }

    sConfig.szLogiciel    = m_aLogiciel.c_str();
    sConfig.szCategorie   = m_aCategorie.c_str();
    sConfig.szCategorieVariables = m_aCategorieVariables.c_str();
    sConfig.eLangue      = m_eLangue;
    sConfig.eOrientation = m_eOrientation;
    sConfig.nCoorDossier = nNoCoord;
    sConfig.bChangerEmet = !m_bModeParametrage;
    sConfig.FctGetValueOfVar = FctGetValueOfVar;
    sConfig.FctGetDescriptionModele = FctGetDescriptionModele;
    sConfig.FctQueryActionModele    = m_FctQueryActionModele;
    sConfig.FctActionModele         = m_FctActionModele;
    sConfig.FctModeleIsVisible      = m_FctModeleIsVisible;
    sConfig.bUtiliseCarnAdr = m_bUtiliseCarnAdr;
    sConfig.bModeParametrage = m_bModeParametrage;
    sConfig.bProtegerModelesFournis       = m_bProtegerModelesFournis;
    sConfig.bMultiLangue                  = m_bMultiLangue;
    sConfig.bGererEnTeteEtPiedDePage      = m_bGererEnTeteEtPiedDePage;
    sConfig.sContrainteTaille.iHEnTeteMax = m_ContrainteTaille->HauteurEnTeteMax;
    sConfig.sContrainteTaille.iHCorpsMax  = m_ContrainteTaille->HauteurCorpsMax ;
    sConfig.sContrainteTaille.iHPiedMax   = m_ContrainteTaille->HauteurPiedMax  ;
    sConfig.sContrainteTaille.iMargeG     = m_ContrainteTaille->MargeG  ;
    sConfig.sContrainteTaille.iMargeD     = m_ContrainteTaille->MargeD  ;
    sConfig.sContrainteTaille.iMargeH     = m_ContrainteTaille->MargeH  ;
    sConfig.sContrainteTaille.iMargeB     = m_ContrainteTaille->MargeB  ;

    for (int i=0 ; i < m_ListCol->Count ; i++)
       {
       sColParametrable = (TColParametrable*)m_ListCol->Items[i];
       if (sColParametrable->TypeColonne != colNonDefinie && sColParametrable->Visible && (sColParametrable->TypeColonne != colPapierEnTete || m_bGererEnTeteEtPiedDePage))
          {
          sParamColCourrier = new TParamColCourrier;
          strncpy(sParamColCourrier->szNomCol, sColParametrable->Libelle.c_str(), 50);
          sParamColCourrier->TypeColonne     = sColParametrable->TypeColonne;
          sParamColCourrier->shWidth         = sColParametrable->Width;
          sParamColCourrier->bAjusterLargeur = sColParametrable->AjusterLargeur;
          sParamColCourrier->Ordre           = sColParametrable->Ordre;
          if (sColParametrable->TypeColonne == colParam1 || sColParametrable->TypeColonne == colParam2)
             sParamColCourrier->slList       = sColParametrable->ListeParametrable;
          else
             sParamColCourrier->slList       = NULL;

          sConfig.lstColonnes->Add(sParamColCourrier);
          }
       }
    sConfig.aLogicielDefaut  = m_aLogicielDefaut  = aLogicielDefaut ;
    sConfig.aCategorieDefaut = m_aCategorieDefaut = aCategorieDefaut;
    sConfig.aLibelleDefaut   = m_aLibelleDefaut   = aLibelleDefaut  ;

    //SI la fonction a déjà été appelée, HandleForm a déjà été allouée, il faut
    //donc la désallouer
    if (HandleForm)
       DesallouerEcran();

    HandleForm = _GererCourriers(Application->MainForm->Handle, Handle,
                                 sConfig,
                                 &NumErreur);

    //SI le n° de coordonné est faux, on retourne false
    if (NumErreur == eCoorInit)
       {
       ASSERT(!m_bModeParametrage); //Les coordonnées ne peuvent être faux en mode paramétrage car ils ne sont pas utilisés.
       bRetour = false;
       }

    while (sConfig.lstColonnes->Count)
       {
       delete ((TParamColCourrier*)sConfig.lstColonnes->Items[0]);
       sConfig.lstColonnes->Delete(0);
       }


   m_bAffichageDemande = true;
  } catch (Exception &e) {
    EICDisplayException(TAG(540), e);
    }
bIsOnAffiche = false;
return bRetour;
}


/*******************************************************************************
void __fastcall CCourrier::WMDestroy(TMessage &Msg)

Fonction :

P.E :

P.E modifiés :

P.S :

Remarque : Lorsque la feuille mère change son type de bordure, l'événement OnDestroy
           est appelé.
           C'est pourquoi, l'événement OnCreate recréer ce qu'à défait le
           OnDestroy et Réaffiche la feuille.
*******************************************************************************/
void __fastcall CCourrier::WMDestroy(TMessage &Msg)
{
try
   {
   TCustomPanel::Dispatch(&Msg);

   //On est obliger de désallouer l'écran ici, car on le désaffecte dan le destructeur,
   //les composants contenu dans cet écran sont déjà désalloués et ça merde !
   DesallouerEcran();
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(550), e);
   }
}

/*******************************************************************************
void __fastcall CCourrier::WMCreate(TMessage &Msg)

Fonction :

P.E :

P.E modifiés :

P.S :
*******************************************************************************/
void __fastcall CCourrier::WMCreate(TMessage &Msg)
{
try
   {
   TCustomPanel::Dispatch(&Msg);

   if (!ComponentState.Contains(csDesigning))
      {
      //SI la fonction Afficher a déjà été appelé par le programmeur, on réaffiche
      if (m_bAffichageDemande)
         Afficher(nNoCoord, m_aLogicielDefaut, m_aCategorieDefaut, m_aLibelleDefaut);
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(560), e);
   }
}

/*******************************************************************************

Fonction :

Paramétres d'entrée :

Paramétres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::SetLogiciel(const AnsiString aLogiciel)
{
try
   {
   m_aLogiciel = aLogiciel.UpperCase();
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(590), e);
   }
}


/*******************************************************************************

Fonction :

Paramétres d'entrée :

Paramétres de sortie :

Valeur retournée :
*******************************************************************************/
__fastcall CCourrier::~CCourrier()
{
try
   {
   if (hEditeur)
      {
      FreeLibrary(hEditeur);
      hEditeur= NULL;
      _GererCourriers     = NULL;
      _GetCoordDossier    = NULL;
      _ChangerCoorDoss    = NULL;
      _DesallouerEcran    = NULL;
      _ChangerLangue      = NULL;
      _ChangerOrientation = NULL;
      }

   if (m_ContrainteTaille)
      {
      delete m_ContrainteTaille;
      m_ContrainteTaille = NULL;
      }

   delete m_ListCol;        m_ListCol = NULL;
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(600), e);
   }
}

/*******************************************************************************

Fonction :

Paramétres d'entrée :

Paramétres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::DesallouerEcran()
{
try
   {
   if (HandleForm)
      {
      if (!hEditeur)
         {
         if((hEditeur = LoadLibrary(aFileNameEicEdito.c_str())) == NULL)
            throw EAbort("Librairie "+ aFileNameEicEdito + " absente.");
         }

      if (!_DesallouerEcran)
         {
         _DesallouerEcran = (FctDesallouerEcran)GetProcAddress(hEditeur, "_DesallouerEcran");
         if( !_DesallouerEcran )
           throw EAbort( "Impossible de charger la fonction _DesallouerEcran.");
         }

      _DesallouerEcran(&HandleForm);
      }
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(610), e);
   }
}

/*******************************************************************************

Fonction :

Paramétres d'entrée :

Paramétres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::MyOnResize(System::TObject* Sender)
{
try
   {
   ::MoveWindow(HandleForm, 0, 0, Width, Height, TRUE);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(620), e);
   }
}

/*******************************************************************************
void ChangerCoorDoss (int nCoorDoss)

Fonction : Cette fonction est appelée lorsque l'écran "gérer courriers" est affiché
           ET que l'on doit changer les coordonné du dossier.

Paramètres d'entrée : nCoorDoss : Nouveau coordonné de dossier

*******************************************************************************/
void __fastcall CCourrier::ChangerCoorDoss (int nCoorDoss)
{
try
   {
   if (!hEditeur)
      throw EAbort("La fonction \"Afficher\" doit d'abord être lancée");

   if (!_ChangerCoorDoss)
      {
      _ChangerCoorDoss = (FctChangerCoorDoss)GetProcAddress(hEditeur, "_ChangerCoorDoss");
      if( !_ChangerCoorDoss )
        throw EAbort( "Impossible de charger la fonction _ChangerCoorDoss.");
      }

   _ChangerCoorDoss(nCoorDoss);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(630), e);
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::SetModeParametrage(bool bModeParametrage)
{
try
   {
   m_bModeParametrage = bModeParametrage;

   if (bModeParametrage)
      m_bUtiliseCarnAdr = false;

   if (ComponentState.Contains(csDesigning))
      Caption = bModeParametrage ? "Ici apparaîtra la liste des courriers paramétrable à l'exécution"
                                 : "Ici apparaîtra la liste des courriers à l'exécution";
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(640), e);
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::SetLangue(IDLangue eLangue)
{
try
   {
   if (eLangue < NB_LANGUES)
      {
      m_eLangue = eLangue;

      //Si l'écran n'est pas alloué, on ne vas pas y changer la langue.
      if (!HandleForm)
         return;

      if (!hEditeur)
         throw EAbort("La fonction \"Afficher\" doit d'abord être lancée");

      if (!_ChangerLangue)
         {
         _ChangerLangue = (FctChangerLangue)GetProcAddress(hEditeur, "_ChangerLangue");
         if( !_ChangerLangue )
           throw EAbort( "Impossible de charger la fonction _ChangerLangue.");
         }

      _ChangerLangue(eLangue);
      }
   else
      ASSERT(false);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(650), e);
   }
}

/*******************************************************************************

Fonction :

Paramètres d'entrée :

Paramètres de sortie :

Valeur retournée :
*******************************************************************************/
void __fastcall CCourrier::SetOrientation(IDOrientation eOrientation)
{
try
   {
   if (eOrientation < NB_ORIENTATIONS)
      {
      m_eOrientation = eOrientation;

      //Si l'écran n'est pas alloué, on ne vas pas y changer la langue.
      if (!HandleForm)
         return;

      if (!hEditeur)
         throw EAbort("La fonction \"Afficher\" doit d'abord être lancée");

      if (!_ChangerOrientation)
         {
         _ChangerOrientation = (FctChangerOrientation)GetProcAddress(hEditeur, "_ChangerOrientation");
         if( !_ChangerOrientation )
           throw EAbort( "Impossible de charger la fonction _ChangerOrientation.");
         }

      _ChangerOrientation(eOrientation);
      }
   else
      ASSERT(false);
   }
catch(Exception &e)
   {
   EICDisplayException(TAG(660), e);
   }
}


namespace Ccourrier
{
   void __fastcall PACKAGE Register()
   {
       TComponentClass classes[1] = {__classid(CCourrier)};
       RegisterComponents("EIC Outils", classes, 0);
   }
}


